package Binarytree;

/*
填充每个节点的下一个右侧节点指针
给定一个完美二叉树，其所有叶子节点都在同一层，每个父节点都有两个子节点。二叉树定义如下：

struct Node {
  int val;
  Node *left;
  Node *right;
  Node *next;
}
填充它的每个 next 指针，让这个指针指向其下一个右侧节点。如果找不到下一个右侧节点，则将 next 指针设置为 NULL。
初始状态下，所有next 指针都被设置为 NULL。

示例 1：
输入：root = [1,2,3,4,5,6,7]
输出：[1,#,2,3,#,4,5,6,7,#]
解释：给定二叉树如图 A 所示，你的函数应该填充它的每个 next 指针，以指向其下一个右侧节点，如图 B 所示。
序列化的输出按层序遍历排列，同一层节点由 next 指针连接，'#' 标志着每一层的结束。
示例 2:
输入：root = []
输出：[]

作者：LeetCode
链接：https://leetcode.cn/leetbook/read/data-structure-binary-tree/xoo0ts/
 */

import java.util.LinkedList;
import java.util.Queue;

public class _33填充每个节点的下一个右侧节点指针 {
    public static void main(String[] args) {

    }

    class Node {
        public int val;
        public Node left;
        public Node right;
        public Node next;

        public Node() {
        }

        public Node(int _val) {
            val = _val;
        }

        public Node(int _val, Node _left, Node _right, Node _next) {
            val = _val;
            left = _left;
            right = _right;
            next = _next;
        }
    }

    //BFS
    //queue.peek  别忘了，他可以取出队列的头部值，而不改变队列
    //O(n)  O(n)
    public Node connect(Node root) {
        if (root == null) {
            return null;
        }
        Queue<Node> queue = new LinkedList<>();
        queue.offer(root);
        while (!queue.isEmpty()) {
            int size = queue.size();
            while (size > 0) {
                Node p1 = queue.poll();
                size--;
                if (p1.left != null) {
                    queue.offer(p1.left);
                }
                if (p1.right != null) {
                    queue.offer(p1.right);
                }
                if (size == 0) {
                    p1.next = null;
                }else {
                    Node p2 = queue.peek();
                    p1.next = p2;
                }
            }
        }

        return root;
    }

    //官解：使用已建立的 next 指针
    //第 N 层节点之间建立 next 指针后，再建立第 N+1 层节点的 next 指针。
    //可以通过 next 指针访问同一层的所有节点，因此可以使用第 N 层的 next 指针，为第 N+1 层节点建立 next 指针。
    //O(n)   O(1)
    class Solution {
        public Node connect(Node root) {
            if (root == null) {
                return root;
            }

            // 从根节点开始
            Node leftmost = root;

            while (leftmost.left != null) {

                // 遍历这一层节点组织成的链表，为下一层的节点更新 next 指针
                Node head = leftmost;

                while (head != null) {

                    // CONNECTION 1
                    head.left.next = head.right;

                    // CONNECTION 2
                    if (head.next != null) {
                        head.right.next = head.next.left;
                    }

                    // 指针向后移动
                    head = head.next;
                }

                // 去下一层的最左的节点
                leftmost = leftmost.left;
            }

            return root;
        }
    }

}
